package cn.tedu.csmall.product.service.impl;


import cn.tedu.csmall.product.ex.ServiceException;
import cn.tedu.csmall.product.mapper.CategoryMapper;
import cn.tedu.csmall.product.pojo.dto.CategoryAddNewDto;
import cn.tedu.csmall.product.pojo.dto.CategoryUpdateDto;
import cn.tedu.csmall.product.pojo.entity.PmsCategory;
import cn.tedu.csmall.product.pojo.vo.CategoryListItemVo;
import cn.tedu.csmall.product.pojo.vo.CategoryStandardVo;
import cn.tedu.csmall.product.service.CategoryService;
import cn.tedu.csmall.product.web.ServiceCode;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Slf4j
@Service
@Transactional
public class CategoryServiceImpl implements CategoryService {

    @Autowired
    private CategoryMapper mapper;

    @Override

    public void addNew(CategoryAddNewDto categoryAddNewDTO) {
        // 调用参数对象的getName()得到尝试添加的类别的名称
        String name = categoryAddNewDTO.getName();
        // 调用Mapper对象的countByName()执行统计查询
        int count = mapper.countByName(name);
        log.debug("根据名称【{}】统计数量，结果：{}", name, count);
        // 判断统计结果是否大于0
        if (count > 0) {
            // 是：名称被占用，抛出异常
            String message = "添加类别失败，类别名称已经被占用！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_CONFLICT, message);
        }

        // 通过参数对象获取parentId
        Long parentId = categoryAddNewDTO.getParentId();
        // 判断parentId是否为0
        Integer depth = 1;
        CategoryStandardVo parentCategory = null;
        if (parentId != 0) {
            // 是：depth（深度）值为：固定为1
            // 否：调用Mapper对象的getStandardById()查询父级类别
            parentCategory = mapper.selectById(parentId);
            //      判断查询结果（父级类别）是否为null
            if (parentCategory == null) {
                //      是：抛出异常
                String message = "添加类别失败，父级类别不存在！";
                log.warn(message);
                throw new ServiceException(ServiceCode.ERROR_NOT_FOUND, message);
            } else {
                //      否：depth（深度值）为：父级类别的depth + 1
                depth = parentCategory.getDepth() + 1;
            }
        }

        // 创建Category对象
        PmsCategory category = new PmsCategory();
        // 复制属性
        BeanUtils.copyProperties(categoryAddNewDTO, category);
        // 补全Category对象的属性值：depth >>>
        category.setDepth(depth);
        // 补全Category对象的属性值：isParent >>> 固定为0
        category.setIsParent(0);
        // 调用Mapper对象的insert()方法执行插入
        int i = mapper.insert(category);
        if (i != 1) {
            String message = "添加类别失败，服务器忙，请稍后再尝试！";
            throw new ServiceException(ServiceCode.ERROR_INSERT, message);
        }


        // 判断parentId是否不为0，并判断父级类别的isParent是否为0
        if (parentId != 0 && parentCategory.getIsParent() == 0) {
            // 是：将父级类别的isParent更新为1
            PmsCategory updateParentCategory = new PmsCategory();
            updateParentCategory.setId(parentId);
            updateParentCategory.setIsParent(1);
            i = mapper.update(updateParentCategory);
            if (i != 1) {
                String message = "添加类别失败，服务器忙，请稍后再尝试！";
                throw new ServiceException(ServiceCode.ERROR_UPDATE, message);
            }
        }
    }

    @Override
    public void delete(Long id) {
        // 调用Mapper对象的getStandardById()执行查询
        // 判断查询结果是否为null，如果是，则抛出异常
        CategoryStandardVo categoryStandardVo = mapper.selectById(id);
        if (categoryStandardVo == null) {
            String message = "删除类别失败，尝试删除的类别数据不存在！";
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND, message);
        }
        // 判断查询结果中的isParent是否为1，如果是，则抛出异常
        Integer isParent = categoryStandardVo.getIsParent();
        if (isParent == 1) {
            String message = "删除类别失败，该类别仍包含子级类别！";
            throw new ServiceException(ServiceCode.ERROR_CONFLICT, message);
        }

        // 调用Mapper对象的deleteById()方法执行删除
        int i = mapper.deleteById(id);
        if (i != 1) {
            String message = "删除类别失败，服务器忙，请稍后再尝试！";
            throw new ServiceException(ServiceCode.ERROR_DELETE, message);
        }
        // 调用Mapper对象的countByParentId方法，根据以上查询结果中的parentId，执行统计
        // 判断统计结果为0，则将父级类别的isParent更新为0
        i = mapper.countByParentId(categoryStandardVo.getParentId());
        if (i == 0) {
            PmsCategory category = new PmsCategory();
            category.setIsParent(0);
            category.setId(categoryStandardVo.getParentId());
            int update = mapper.update(category);
            if (update != 1) {
                String message = "删除类别失败，服务器忙，请稍后再尝试！";
                throw new ServiceException(ServiceCode.ERROR_UPDATE, message);
            }
        }
    }

    @Override
    public void setEnable(Long id) {
        updateEnableById(id, 1);
    }

    @Override
    public void setDisable(Long id) {
        updateEnableById(id, 0);
    }

    @Override
    public List<CategoryListItemVo> listByParentId(Long parentId) {
        log.debug("开始处理【根据父级类别查询子级类别列表】的业务，参数：{}", parentId);
        List<CategoryListItemVo> list = mapper.listByParentIds(parentId);
        return list;
    }

    @Override
    public void setIsDisplay(Long id) {
        updateIsDisplay(id,1);
    }

    @Override
    public void setNotDisplay(Long id) {
        updateIsDisplay(id,0);
    }

    private void updateIsDisplay(Long id,Integer display){
        CategoryStandardVo categoryStandardVo = mapper.selectById(id);
        if (categoryStandardVo == null) {
            String message = DISPLAY_TEXT[display] + "类别失败，类别数据不存在！";
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND,message);
        }
        Integer isDisplay = categoryStandardVo.getIsDisplay();
        if (isDisplay == display) {
            String message = DISPLAY_TEXT[display] + "类别失败，此类别已经处于" + DISPLAY_TEXT[display] + "状态！";
            throw new ServiceException(ServiceCode.ERROR_CONFLICT,message);
        }
        PmsCategory pmsCategory = new PmsCategory();
        pmsCategory.setId(id);
        pmsCategory.setIsDisplay(display);
        int update = mapper.update(pmsCategory);
        if (update != 1){
            String message = DISPLAY_TEXT[display] + "类别失败，服务器忙，请稍后再尝试！";
            throw new ServiceException(ServiceCode.ERROR_UPDATE,message);
        }
    }

    private void updateEnableById(Long id, Integer enable) {
        // 调用Mapper对象的getStandardById()方法执行查询
        CategoryStandardVo currentCategory = mapper.selectById(id);
        // 判断查询结果是否为null，如果是，则抛出异常
        if (currentCategory == null) {
            String message = ENABLE_TEXT[enable] + "类别失败，类别数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND, message);
        }

        // 判断查询结果中的enable与参数enable是否相同，如果是，则抛出异常（当前状态与目标状态相同，没必要执行更新）
        if (currentCategory.getEnable() == enable) {
            String message = ENABLE_TEXT[enable] + "类别失败，此类别已经处于" + ENABLE_TEXT[enable] + "状态！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_CONFLICT, message);
        }

        // 创建Category对象
        PmsCategory updateCategory = new PmsCategory();
        // 向Category对象中封装属性值：id, enable，均来自方法参数
        updateCategory.setId(id);
        updateCategory.setEnable(enable);
        // 调用Mapper对象的update()方法执行更新
        int rows = mapper.update(updateCategory);
        if (rows != 1) {
            String message = ENABLE_TEXT[enable] + "类别失败，服务器忙，请稍后再尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_UPDATE, message);
        }
    }

    @Override
    public void updateInfoById(Long id, CategoryUpdateDto categoryUpdateDto) {
        log.debug("开始处理【修改类别详情】的业务，ID：{}，新数据：{}", id, categoryUpdateDto);
        // 调用Mapper对象的getStandardById()执行查询
        CategoryStandardVo queryResult = mapper.selectById(id);
        // 判断查询结果是否为null
        if (queryResult == null) {
            // 是：抛出异常
            String message = "修改类别详情失败，尝试修改的类别数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND, message);
        }

        // 调用Mapper对象的countByNameAndNotId()执行统计
        int count = mapper.countByNameNotById(categoryUpdateDto.getName(),id);
        // 判断统计结果是否大于0
        if (count > 0) {
            // 是：名称被占用，抛出异常
            String message = "修改类别详情失败，类别名称已经被占用！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_CONFLICT, message);
        }

        // 创建Category对象
        PmsCategory category = new PmsCategory();
        // 复制属性，设置ID
        BeanUtils.copyProperties(categoryUpdateDto, category);
        category.setId(id);
        // 调用Mapper对象的update()方法执行修改
        int rows = mapper.update(category);
        if (rows != 1) {
            String message = "修改类别详情失败，服务器忙，请稍后再尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_UPDATE, message);
        }
    }

    @Override
    public CategoryStandardVo getStandardById(Long id) {
        log.debug("开始处理【根据ID查询类别详情】的业务，参数：{}", id);
        CategoryStandardVo queryResult = mapper.selectById(id);
        if (queryResult == null) {
            // 是：抛出异常
            String message = "查询类别详情失败，类别数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND, message);
        }
        return queryResult;
    }
}
